Copyright: Copyright 1995, Kustom Magic Software


Adding properties
Add new properties

Sealit will allow you to add as many new properties as you wish. Unless you have though it through, you will most likely change the buffer. The kinds of properties you may add are: strings, int, and longs. You can also add Boolean and timedates properties but they get converted to integers and longs. You can change the property type by changing the entry in the combobox. Then you will need to give the property a name. I am a Hungarian notation fan so I automatically start off the name with Hungarian notation. If you don't like it, then just press backspace and all the highlighted text will disappear.

So let's add szCompany for our name. Press tab or click on the length edit box. This is where you will enter the length of the string. Let's enter 30. Press tab again to get the edit box where we will enter our data. Enter your company name. If your company name is greater than 30 characters, then change the length to accommodate. For example if this would be a field that you are going to seal in the future, then you can click the No Value check box. This will let Wizard know that aren't entering data. Press OK. If you wish to enter more properties, you can press Save instead. But for our tutorial, we will continue. Click on szCompanyName. You will see your data underneath the listbox. If you wish to add a comment for your programming purposes, you can do this in the comments edit box. This data will NOT be saved in your exe. This is just for you.

Normally you will have more properties in your buffer but this will do for now. Click the Generate menu option. You will see the Generate DialogBox. Choose the directory and new subdirectory in which you wish to generate code. Depending on the what code you are production, you have some different options. They are pretty much self-explanatory.

In General options, there are three checkboxes. Create MAK file and Start application after code generation and quit Wizard will let the Wizard create a mak file and spawns either Visual Basic or Visual C. If Start application after code generation and quit Wizard is not enabled, then you do not have your options set correctly. Press generate and Wizard will automatically generate the correct files. If Start application after code generation and quit Wizard checkbox checked, then Wizard will run the appropriate application. Now you start coding your application. Once you are done, then we will seal your executable.


DeInitializeBuffer

  ******************************************************************************

Purpose:

Deintializes the allocated buffer from InitializeBuffer

This will only be used if you want data in the buffer that is embedded in the

EXE to change

Example:

C:

DeInitializeBuffer();

VB:

DeInitializeBuffer

Also see:

InitializeBuffer

SaveInt

SaveLong

SaveString

SealApplication

Supported Revision:

  1.0

Syntax:

    C Prototype:

void DeInitializeBuffer(void)

    VB Declare:

    	Declare Sub DeInitializeBuffer Lib "sealer.dll" ()

Returns:

Nothing

Parameters:

None

******************************************************************************


API Example


GetSealError

******************************************************************************

Purpose:

    	Returns an error string. The error string must be at least 250 bytes long. Bad things will happen if you do not do this!!!!

Example:

C:

char szErrorString[250];

GetSealError(ERRSEAL_CANTALLOCBUFFER,szErrorString)

VB:

Dim szErrorString as string * 250

GetSealError ERRSEAL_CANTALLOCBUFFER,szErrorString

Also see:

Supported Revision:

  1.0

Syntax:

    C Prototype:

    	void GetSealError(int wError,char *szErrorString)

    VB Declare:

Declare Sub GetSealError Lib "sealer.dll" (ByVal wErrorCode%, ByVal lpszErrorString$)

Returns:

Nothing

Parameters:

wError:

INT - The error a Sealit Function returned

szErrorString:

STRING - A buffer of at least 250 bytes in length to receive the buffer

******************************************************************************


GetAPIVersion

******************************************************************************

Purpose:

To retrieve the API version number.

Supported Revision:

1.0

Syntax:

  C Prototype:

void GetAPIVersion(lpVERSION lpVersion)

  VB Declare:

Declare Sub GetAPIVersion Lib "sealit.dll" (Version as Version)

Returns:

Nothing

Parameters:

VERSION

C struct:

typedef struct tagVersion

  	  	int iMajor;

  	  	int iMinor;

  	  	int iPatch;

  	  	int bBeta;

 VERSION,*pVERSION,far *lpVERSION;

VB Type:

Type Version

iMajor as integer

iMinor as integer

iPatch as integer

bBeta as integer

End Type

******************************************************************************


API Index
Sealit API

  ValidateApplication

  SealApplication

  ConvertTimeFromLong

  ConvertTimeToLong

  GetSealError

  GetAPIVersion

  InitializeBuffer

  SaveInt

  SaveLong

SaveString

  DeInitializeBuffer


InitializeBuffer

******************************************************************************

Purpose:

This initializes the buffer that you will be saving. The Wizard should have

created the buffer that you wanted to save. This should be the length ALWAYS!

This will only be used if you want data in the buffer that is embedded in the

EXE to change

Example:

C:

if(InitializeBuffer(sizeof(WIZARDCREATEDBUFFER)) == 0)

VB:

wReturn% = InitialBuffer(len(WIZARDCREATEDBUFFER))

Also See:

DeInitializeBuffer

SaveInt

SaveLong

SaveString

SealApplication

Supported Revision:

1.0

Syntax:

C Prototype:

int InitializeBuffer(int wLen)

    	VB Declare:

Declare Function InitializeBuffer Lib "sealer.dll" (ByVal wLen%)

  	Returns:

0

ERRSEAL_CANTALLOCBUFFER

Parameters:

wLen:

INT - The length of the buffer that Wizard created.

  ******************************************************************************


Application Info Type
Type lpAPPINFO

     bOverWriteSeal As Integer

     szMagicString As String * 20

     szAppName As String * 260

End Type


SealApplication

******************************************************************************

Purpose:

This will 'seal' the pre-defined and filled buffer to the EXE. This will only be used if

you want data in the buffer that is embedded in the EXE to change

Example:

C:

if((wRet = SealApplication(lpAppInfo,wBufferLen)) == 0)

VB:

wRet% = SealApplication(lpAppInfo,wBufferLen)

Also see:

DeInitializeBuffer

InitializeBuffer

SaveLong

SaveInt

SaveString

Supported Revision:

  1.0

Syntax:

    C Prototype:

    	int SealApplication(LPAPPINFO lpAppInfo, int wBufferLen)

    VB Declare:

Declare Function SealApplication Lib "sealer.dll" (lpAPPINFO As lpAPPINFO, ByVal wBufferLen%) As Integer

Returns:

0

ERRSEAL_BADFOPEN

ERRSEAL_OVERWRITESEALED

ERRSEAL_SEALED

ERRSEAL_SEEKFAILED

ERRSEAL_NOPROGRAMNAME

ERRSEAL_NOMAGICSTRING

ERRSEAL_NOOVERSEALFLAG

Parameters:

LPAPPINFO:

C struct:

typedef struct tagAppInfo

int 	bOverWriteSeal;

char 	szMagicString[20];

char  szAppName[260];

 APPINFO, * PAPPINFO, far *LPAPPINFO;

VB Type:

Type lpAPPINFO

     	bOverWriteSeal As Integer

    	 	szMagicString As String * 20

     	szAppName As String * 260

End Type

This structure needs to be filled out before any sealit calls with this parameter

can be excuted.

bOverWriteSeal 	= TRUE or FALSE - Overwrite any existing seal if one is found

szMagicString  	= your magic string

   	szAppName	= path and exe to be sealed

  	wBufferLen:

  	INT

 The len of the buffer that Wizard created.

******************************************************************************


SaveInt

******************************************************************************

Purpose:

Saves a integer to the buffer

This will only be used if you want data in the buffer that is embedded in the

EXE to change

Example:

C:

SaveInt(1)

VB:

SaveInt 1

Also see:

DeInitializeBuffer

InitializeBuffer

SaveLong

SaveString

SealApplication

Supported Revision:

  1.0

Syntax:

    C Prototype:

void SaveInt(int wValue)

    VB Declare:

    	Declare Sub SaveInt Lib "sealer.dll" (ByVal wValue%)

Returns:

Nothing

Parameters:

wValue:

INT - The integer you want saved

******************************************************************************


SaveLong

******************************************************************************

Purpose:

Saves a long to the buffer

This will only be used if you want data in the buffer that is embedded in the

EXE to change

Example:

C:

SaveLong(1)

VB:

SaveLong 1

Also see:

DeInitializeBuffer

InitializeBuffer

SaveInt

SaveString

SealApplication

Supported Revision:

  1.0

Syntax:

    C Prototype:

void SaveLong(long lValue)

    VB Declare:

    	Declare Sub SaveLong Lib "sealer.dll" (ByVal lValue&)

Returns:

Nothing

Parameters:

lValue:

LONG - The long you want saved

******************************************************************************


SaveString

******************************************************************************

Purpose:

Saves a string of 'n' length to the buffer. For safety, in Visual Basic,

the string should have a NULL (chr$(0)) appended to it like the example

below shows. This will only be used if you want data in the buffer that

is embedded in the EXE to change

Example:

C:

SaveString("Kustom Magic Software",40)

VB:

    SaveString(szFirstName$ & Chr$(0), 15

Also see:

DeInitializeBuffer

InitializeBuffer

SaveLong

SaveInt

SealApplication

Supported Revision:

  1.0

Syntax:

    C Prototype:

void SaveString(char *szValue,int wLen)

    VB Declare:

    	Declare Sub SaveString Lib "sealer.dll" (ByVal lpszValue$, ByVal wLen%)

Returns:

Nothing

Parameters:

szValue:

STRING - The string you want saved

wLen:

INT - The length of the string you want saved. Can be longer than

the string passed in but not shorter.

******************************************************************************


ConvertTimeToLong
ConvertDateToLong

******************************************************************************

Purpose:

Converts a date to a long

Example:

C:

tmDate = ConvertDateToLong(1,1,95,12,0);

VB:

lConvertedDate& = ConvertDateToLong(wMonth%, wDay%, wYear%)

Also see:

Supported Revision:

  1.0

Syntax:

    C Prototype:

    	long ConvertDateToLong(int wMonth, int wDay, int wYear)

    VB Declare:

Declare Function ConvertDateToLong Lib "sealer.dll" (ByVal wMonth%, ByVal wDay%, ByVal Year%) As	Long

Returns:

A long equal to the Date entered

Parameters:

INT:

wMonth 	- 1 thru 12

INT:

wDay   	- 1 thru 31

INT:

wYear  	- the last two digits of the year; Ex 95 for 1995

******************************************************************************


ConvertTimeFromLong

******************************************************************************

Purpose:

Convert the long returned from ConvertTimeToLong to a readable time

Example:

C:

int wMonth,wDay,wYear,wHour,wMinutes;

      	ConvertTimeFromLong(ttTimeValue,&wMonth,&wDay,&wYear,&wHour,&wMinutes)

VB:

Dim wMonth%, wDay%, wYear%, wHour%, wMinutes% ,tmExpire&

        	ConvertTimeFromLong  tmExpire&, wMonth%, wDay%, wYear%, wHour%, wMinutes%

Also see:

Supported Revision:

  1.0

Syntax:

    C Prototype:

Void ConvertTimeFromLong(time_t ttTimeValue, int *pwMonth, int *pwDay, int *pwYear, int *pwHour, int *pwMinutes)

    VB Declare:

Declare Sub ConvertTimeFromLong Lib "sealer.dll" (ByVal lTime&, wMonth%, wDay%, wYear%, wHour%, wMinutes%)

Returns:

Nothing

Parameters:

TIME_T:

ttTimeValue - The value returned from ConvertTimeToLong

INT:

wMonth	- The month returned

INT:

pwDay	- The day returned

INT:

wYear	- The year returned

INT:

wHour	- The hour returned

INT:

wMinutes	  	- The minutes returned

******************************************************************************


ValidateApplication

******************************************************************************

Purpose:

Validates an application. Check for the seal in the EXE and returns the buffer

information that was written.

Example:

C:

WIZARDBUFFER 	WizardBuffer; //<- buffer wizard created

      	VERSION	 AppInfo;

      	if ((wErr = ValidateApplication(&AppInfo, sizeof(WizardBuffer), &WizardBuffer)) == 0)

VB:

Dim WizardBuffer as WIZARDBUFFER '<- buffer wizard created

      	Dim AppInfo as VERSION

wErr% = ValidateApplication(lpAPPINFO, len(Wizard), Wizard)

Also see:

Supported Revision:

  1.0

Syntax:

    C Prototype:

        	int ValidateApplication(LPAPPINFO lpAppInfo, int wBufferLen, void *vpBuffer)

    VB Declare:

    	Declare Function ValidateApplication Lib "sealer.dll" (lpAPPINFO As lpAPPINFO, ByVal wBufferLen%, vpBuffer As Any) As Integer

Returns:

0

ERRSEAL_NOPROGRAMNAME

ERRSEAL_NOMAGICSTRING

ERRSEAL_NOOVERSEALFLAG

ERRSEAL_BADFOPEN

ERRSEAL_READFAILED

ERRSEAL_READNOTEQUALTOBUFFERSIZE

ERRSEAL_NOTSEALED

ERRSEAL_SEEKFAILED

Parameters:

LPAPPINFO:

C struct:

typedef struct tagAppInfo

int    	bOverWriteSeal;

char 	szMagicString[20];

char  	szAppName[260];

 APPINFO, * PAPPINFO, far *LPAPPINFO;

VB Type:

Type lpAPPINFO

     	bOverWriteSeal As Integer

    	 	szMagicString As String * 20

     	szAppName As String * 260

End Type

This structure needs to be filled out before any sealit calls with this parameter

can be excuted.

bOverWriteSeal 	= TRUE or FALSE - Overwrite any existing seal if one is found

szMagicString  	= your magic string

      	szAppName	= path and exe to be sealed

  	wBufferLen:

  	INT:

  	The len of the buffer that Wizard created.

      	vpBuffer:

      	VOID:

      	The data of the buffer

******************************************************************************


Author
Contacting the Author

You can contact Ralph Krausse at Kustom Magic Software:

Internet: 	ralphk@primenet.com

CompuServe:	71043,2434

Tech support can only be handled through e-mail. This is not my normal job, it is a side hobby. That is why it is Shareware. Since it is Shareware, I don't have people on phones waiting for problem reports. Besides, I live in an apartment and I would have no room for them. Therefore, I can only support via e-mail. I check my Internet mail about 4-5 daily so contacting me won't be a problem. If we run into a major bug, and we need to phone each other, well we'll cross that bridge if we get there. Hopefully we won't.


Code
What kind of code does Wizard Generate

Wizard will generate four types of code. Visual Basic, C for DOS, C for Windows and C for DLLs. You should be able to create a buffer, generate the code, and compile each generate type off the bat with NO modifications. This won't produce to much for you other than showing you what is in the buffer  you created.

Each produces different results of a successful 'seal'.

To see the buffer value(s) in Visual Basic, you need to trace through the code in the debugger. There are comments for this in the Visual Basic code. You should be able Shift-F8 over the buffer variables and see them.

C for DOS will show you all the buffer variables that you created. You should be able to compile, seal and run the executable and see the information that you saved in the buffer.

C for Windows will only show you the Magic String from the About menu item.

C for DLL is a dll and is not able to run itself so you have to create a Windows or Visual Basic program to use it.

Though some programs will show you all or some of the seal buffer, the entire seal is in memory. Just follow the Quick Start/Tutorial and it will make sense.


Contents Page
Sealit Help Contents

  What is Sealit?

  Tutorial

  Helpful tips when programming

  API Functions

  A program named "foo"

  What kind of code does Wizard Generate

  Error Codes

 Can I use Sealit on a program that is already done?

  What is Shareware

  Author


Copyright
This Windows Help file was written by Graham Plowman

using Help Builder Version 1.07 and refers to:

XXXXXX Version X.YY / 01/22/96

Copyright 1993, 1994, 1995 G.Plowman


Use on finished programs
Can I use Sealit on a program that is already done?

Well, yes and no. It would be a two part step that would require code changes. I know you are saying sh*t! But it isn't as bad as you think. This is what you must do. First create your seal buffer using the Wizard and generate the code. I recommend that you create the make file and start Visual Basic or MSVC after code generation. If the checkbox is not enabled, then you haven't specified the path. Change this in the options dialog box.

Then when the parent application is loaded then you can just copy the necessary code (all headers and the ValidateApplication call) to your program. You can also cut from the 'foo' program. This example also uses functions that you can use. Then you have to use the Sealer program to seal you exe.

That is about it. It is a little more involved than this but I will be available on e-mail support.


Error Codes

The error codes for Sealit are below. This is just really for your information. The GetSealError function will retrieve the error string or the error code passed in.

ERRSEAL_BASE	9000

This is just the base error. Don’t worry about this one.

ERRSEAL_BADFOPEN 	(ERRSEAL_BASE + 1)

Description: Sealit couldn't open the file that was specified in the Application Info Type. The common mistake here is that you go to

Wizard, create a buffer, generate code, and then step through your code. There isn't an executable.

How to fix: Compile and exe first.

ERRSEAL_NOTSEALED	(ERRSEAL_BASE + 2)

Description: Sealit couldn't find a seal. Either there was no seal or if you know there is a seal then the magic strings don't match.

How to fix: Either seal the application first or fix the magic string.

ERRSEAL_NOPROGRAMNAME           	(ERRSEAL_BASE + 3)

Description: The Application Info Type is fully filled out. There isn't a program name defined.

How to fix: Define a executable name.

ERRSEAL_NOMAGICSTRING          	 	(ERRSEAL_BASE + 4)

Description: The Application Info Type is fully filled out. There isn't a magic string defined.

How to fix: Define a magic string.

ERRSEAL_SEALED                 	 	(ERRSEAL_BASE + 5)

Description:  This isn't really an error code rather a verification that the application was sealed.

How to fix: Not broken.

ERRSEAL_NOOVERSEALFLAG          	(ERRSEAL_BASE + 6)

Description: The Application Info Type is fully filled out.  The overwriteseal flag want properly initialized.

How to fix: 0 if you don't want to over write the seal, 1 if you do.

ERRSEAL_READNOTEQUALTOBUFFERSIZE	(ERRSEAL_BASE + 7)

Description:  The seal was read but the size of the buffer and the number of bytes didn't match. This should never happen but then we

shouldn't have acid rain.

How to fix: Write Kustom Magic Software.

ERRSEAL_SEEKFAILED	(ERRSEAL_BASE + 8)

Description: Couldn't seek through the file. This is a major problem.

How to fix: Write Kustom Magic Software.

ERRSEAL_READFAILED                	(ERRSEAL_BASE + 9)

Description: There was an error reading the seal. This is a major problem.

How to fix: Write Kustom Magic Software.

ERRSEAL_CANTALLOCBUFFER	           	(ERRSEAL_BASE + 10)

Description: Couldn’t' allocate enough memory. Decrease the size of the buffer.

How to fix: Write Kustom Magic Software.

ERRSEAL_OVERWRITESEAL           	(ERRSEAL_BASE + 11)

Description:  This isn't really an error code rather a verification that the seal was overwritten.

How to fix: Not broken.


foo
A program named "foo"

Foo is an example to show you how to write information to an executable. The executable has been sealed with the foo make file. In the initialize sub routine, foo fills out the gApplicationInfo type. Then we get the size of the type. Then we read the seal with ValidateApplication. If there wasn't a seal, we'd get back ERRSEAL_NOTSEALED (9002). The executable should be sealed already but if it isn't, just seal it with sealer and the foo.kms file. Once sealit reads the seal, the foo type will be filled out with the sealed information. Now we find out if this is the first time we have run this application. When I used sealit to seal foo, the type I created had the bFirstTime variable which I set to true. So we check it with 'If gfoo.bFirstTime = True'. If it is true, then we show the register form. Once the name and company name fields have some value, then we can re-seal the application. The saveinfo subroutine does this for us.

First we must set gApplicationInfo.bOverWriteSeal = True so we over write the seal in the exe. Otherwise sealit will return then ERRSEAL_SEALED error. Then we must initialize the dll buffer with InitializeBuffer function. You must do this before saving any variables.  Since out foo type has been constructed like this;

Type foo

    bFirstTime As Integer

    dtExpirationDate As Long

    szCompany As String * 60

    szName As String * 40

    szMagicString As String * 20

End Type

we must save the information in the same order. Failure to this will screw things up. So we must fist save bFirstTime, then dtExpirationDate, then szCompany, etc. Since bFirstTime is declared as an integer, use then SaveInt function to save it to the buffer. To create and expiration date, we must first convert the VB date to a long. We do this by using the ConvertDateToLong. You pass in the month, day, and year and the dll will pass you back the a long equal to the date passed in. Save the date using SaveLong function.  Now we save the strings. READ CAREFULLY.

We save the company name with SaveString CStr(frmRegister!txtCompany.Text) & Chr$(0), 60. Notice that we append a NULL (chr$(0)) to the end of the string. This is very important. We also pass in the len of the string including the null. So in other words. the string can be 59 characters long to save the last character for the null. In our foo type, szCompany has been declared as string * 60 so we MUST save 60 characters. To play it save. if you have a string * x, x will be the last parameter in SaveString.  Once szName and szMagicString are saved then we call SealApplication to embed the new seal in the exe. Then call DeInitializeBuffer to free memory. If successful, then we must restart the exe. Do it and you will see what happens.

Thing to remember

ALL STRINGS IN THE TYPE MUST BE DECLARED AS STRING * X

szMagicString MUST BE THE LAST PROPERTY TO BE SAVED


Gerating Code


Intro
Sealit Introduction

What is Sealit? Sealit allows you to save information into an executable. Many programmers have found a problem when it comes to having their software registered. Some put registration information into ini files, some into file, encryption is implemented, it basically has become a problem and a problem to me. Sealit overcomes this problem by saving the information you want right into the executable. This way, no one can mess with it, most everyone won't even know where to look.

I have created Sealit for the programmer. This is not a tool for anyone, it is a programmers tool. Sealit is two applications. You start with the Wizard. It will allow you to create a "buffer" that will hold your information. Once the buffer is created, the Wizard can generate Visual Basic, C (DOS, and Windows) code. The next version will generate DLL, VBX and OCX code. Then with a skeleton of a program, you then write whatever you wanted to create. Once you have an executable, you use the Sealer to "seal" the buffer you created in the executable. Then you are done. There is more but basically that is it.

Once you get the hang of if, it is real easy to use. I am very excited about Sealit and hope that is solves many problems. Sealit was build mainly for self-registration but it can be used to save any information into the executable. So go to it. You've got a free 45 days to use it. By the way, the Wizard uses the same technology. It is sealed with a buffer. So Wizard and Sealer are prime examples of what can be done. One more issue, if you are a big company wanting to buy the rights to Sealit for a million or there abouts, e-mail me. We can talk. :)

Enjoy. Please send any question to ralphk@primenet.com.


Magic String
The way sealit can identify if the executable has a seal in it.


Untitled
Wizard Options


Magic String
The magic string will be your identifier. This is the field that will get checked first when you program gets run. If you seal your program with a magic string of !!!kms!!!, then your API function need to be initialized with this same magic string. I will explain later if you are confused. If you don't the whole process won't work.


New Project


Options


View Type


Sealer


Wizard


Sealing
Sealing an executable

To seal an application with your buffer, you will need Sealer. This utility will take the kms file that the Wizard created and uses its information to correctly write the information that is in your buffer to the executable. If you have more than one application that you want sealed with the same buffer information, just add them to the listbox under 'Programs to Seal'. When you are ready, press the Seal button and Sealer will apply the seal to each executable. If Sealer finds a seal already in the executable it will notify you. It can recognize the seal only if the seal you're writing and seal that is in the executable have the same magic string. If you have the Over Write Existing Seal checkbox checked, it will ignore a found seal and over write it.

If you are sealing the executable that you are running, you will have to exit out of the program and re-start it. The sealing of an executable while in memory is OK, but you really need to re-load it once sealed. If you don't bad things might happen. This is a 'threat' comes from windows not from me. Sealing the application will rearrange addresses in memory that Windows knows about. After sealing, the address of functions and variables is not correct and your program will act funny and will not do what you programmed it to. Exiting the program and re-running it will fix ALL OF THIS!


What is Shareware ?

Definition of Shareware

Shareware distribution gives users a chance to try software before buying it. If you try a Shareware program and continue using it,

you are expected to register. Individual programs differ on details: some request registration while others require it, some specify a

maximum trial period. With registration, you get anything from the simple right to continue using the software to an updated program

with printed manual.

Copyright laws apply to both Shareware and commercial software, and the copyright holder retains all rights. Shareware authors

are accomplished programmers, just like commercial authors, and the programs are of comparable quality. (In both cases, there

are good programs and bad ones!) The main difference is in the method of distribution. The author specifically grants the right to

copy and distribute the software, either to all and sundry or to a specific group. For example, some authors require written

permission before a commercial disk vendor may copy their Shareware.

Shareware is a distribution method, not a type of software. You should find software that suits your needs and pocketbook, whether

it's commercial or Shareware. The Shareware system makes fitting your needs easier, because you can try before you buy.

And because the overhead is low, prices are low also. Shareware has the ultimate money-back guarantee: if you don't use the

product or it doesn't do what you want it to do or you don't like it, then you don't pay for it.


Tips
Helpful tips when programming

Sealit works on the executable. Therefore, if you do not have an executable, sealit won't work. Most of you will already have your applications created when you get Sealit. So you will have to run Wizard, create you buffer, generate code and then cut and paste.

Visual Basic Programmers

Create an executable. This can be the executable that you want sealed or not. The API functions have a Application Info Type as one of their input parameters. This szAppName is where you specify your executable that you what to check for a seal. If you are coding "Application A" but have "ApplicationB.exe" in the szAppName type variable, your application when run will check that executable. Why do you want to do this. For debugging. Obviously ApplicationB.exe must be sealed with the buffer you created for Application A. If you are confused, do worry. There are examples that will show this. Once you see, you will say "Ahh ok, now I understand. I don't feel dumb" This way when you are debugging, Sealit will get the buffer from ApplicationB.exe instead of the one you are writing. When you are finished, you can then seal ApplicationA (the one you were writing) and know that it will work.

C Programmers

You also read the paragraph above and then follow it also but just in the C environment. Also, once a executable is sealed,

CodeView and CodeView for Windows and the MSVC debugger will NOT work.

NOTE

This is very important. If you seal an executable, then continue to code and recompile you exe, the seal will be gone. You will have to reseal it. This can be a pain, so the work around for right now it to have you application check the seal of a fake exe. This way you can recompile till your hearts content and you won't have to reseal. Again, there are examples of this.


Tutorial

The steps:

 	1. Using the Wizard, create a buffer of the information that you want saved to the executable.

2. Generate code for your language, and continue to code your application.

3. Seal the executable.

Start by creating a new project. You can do this by the File/New project menu option or clicking the new project button [image]. If you do not have default magic string defined in the options dialog, then the property dialog will appear. For a new project, the property type will be string, the type name will be szMagicString and length will be 20 character. The magic string is the only property  you are not allowed to modify other than the data that you will enter. Pick a magic string and press OK. You will see that szMagicString has been entered. You know it contains data because of the green dot next to it. If it doesnt contain data, there wouldn't be a dot.The red dots indicate that those entries are not allowed to be modified. If you click on the szMagicString entry, you will see the value underneath the listbox.

Next you will want to name your project. Enter Test under project name. Then you will want to enter a buffer name. Enter Test under buffer name. You will notice that the data will be put in the listbox as you type the buffer name. If it hasn't already clicked, you are creating a structure ( for C) or type (for Visual Basic) in memory. You can change the view type and see either a Visual Basic type or a C struct. Then continue with adding new properties.